package com.pur.zsms.storemanage.service.impl;

import java.math.BigDecimal;
import java.math.MathContext;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import javax.annotation.Resource;

import net.sf.cglib.beans.BeanCopier;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;

import org.springframework.stereotype.Service;

import com.pur.zsms.common.exception.GenericException;
import com.pur.zsms.common.support.PageController;
import com.pur.zsms.common.support.PaginationSupport;
import com.pur.zsms.dao.IDistributorDao;
import com.pur.zsms.foodmanage.food.po.FoodPo;
import com.pur.zsms.foodmanage.food.vo.FoodVo;
import com.pur.zsms.matermanage.mater.dao.IMaterDao;
import com.pur.zsms.matermanage.mater.po.MaterLevelPo;
import com.pur.zsms.matermanage.mater.po.MaterPo;
import com.pur.zsms.ordercustommanage.po.OrderCustPo;
import com.pur.zsms.ordercustommanage.po.OrderDistributorMaterRealPo;
import com.pur.zsms.ordercustommanage.po.OrderSupplierMaterRealPo;
import com.pur.zsms.ordercustommanage.vo.SelectFoodVo;
import com.pur.zsms.pmsnmanage.user.po.UserPo;
import com.pur.zsms.storemanage.dao.IStoreDao;
import com.pur.zsms.storemanage.po.StoreInDetailedPo;
import com.pur.zsms.storemanage.po.StoreInPo;
import com.pur.zsms.storemanage.po.StoreMaterDetailPo;
import com.pur.zsms.storemanage.po.StoreMaterPo;
import com.pur.zsms.storemanage.po.StoreOutDetailedPo;
import com.pur.zsms.storemanage.po.StoreOutDetailedValuePo;
import com.pur.zsms.storemanage.po.StoreOutPo;
import com.pur.zsms.storemanage.po.StorePo;
import com.pur.zsms.storemanage.service.IStoreService;
import com.pur.zsms.storemanage.vo.SStoreMaterVo;
import com.pur.zsms.storemanage.vo.StoreInDetailedVo;
import com.pur.zsms.storemanage.vo.StoreInVo;
import com.pur.zsms.storemanage.vo.StoreMaterVo;
import com.pur.zsms.storemanage.vo.StoreOutDetailedVo;
import com.pur.zsms.storemanage.vo.StoreOutVo;
import com.pur.zsms.storemanage.vo.StoreVo;
import com.pur.zsms.supplier.dao.SupplierDao;
import com.pur.zsms.supplier.dao.SupplierOrderDao;
import com.pur.zsms.supplier.po.SupplierPo;
import com.pur.zsms.systemsetting.datadictionary.dao.IDataDictionaryDao;
import com.pur.zsms.systemsetting.datadictionary.po.Code;

@Service("storeService")
public class StoreServiceImpl implements IStoreService {
	String msg = "";

	public String getMsg() {
		return msg;
	}

	public void setMsg(String msg) {
		this.msg = msg;
	}

	@Resource(name = "distributorDao")
	private IDistributorDao distributorDao;

	@Resource(name = "dataDictionaryDao")
	private IDataDictionaryDao dataDictionaryDao;

	@Resource(name = "supplierOrderDao")
	private SupplierOrderDao supplierOrderDao;

	public SupplierOrderDao getSupplierOrderDao() {
		return supplierOrderDao;
	}

	public void setSupplierOrderDao(SupplierOrderDao supplierOrderDao) {
		this.supplierOrderDao = supplierOrderDao;
	}

	@Resource(name = "materDao")
	private IMaterDao materDaoImpl;

	@Resource(name = "storeDao")
	private IStoreDao storeDao;

	@Resource(name = "supplierDao")
	private SupplierDao supplierDao;

	public SupplierDao getSupplierDao() {
		return supplierDao;
	}

	public void setSupplierDao(SupplierDao supplierDao) {
		this.supplierDao = supplierDao;
	}

	public IStoreDao getStoreDao() {
		return storeDao;
	}

	public void setStoreDao(IStoreDao storeDao) {
		this.storeDao = storeDao;
	}

	public IMaterDao getMaterDaoImpl() {
		return materDaoImpl;
	}

	public void setMaterDaoImpl(IMaterDao foodDaoImpl) {
		this.materDaoImpl = foodDaoImpl;
	}

	@Override
	public PaginationSupport listStore(PageController pageController, StoreVo storeVo) throws GenericException {
		return storeDao.listStore(pageController, storeVo);
	}

	@Override
	public PaginationSupport listStoreIn(PageController pageController, StoreInVo storeInVo) throws GenericException {
		return storeDao.listStoreIn(pageController, storeInVo);
	}

	public PaginationSupport listStoreInForSupplier(PageController pageController, StoreInVo storeInVo) throws GenericException {
		return storeDao.listStoreInForSupplier(pageController, storeInVo);
	}

	public PaginationSupport listStoreOutForSupplier(PageController pageController, StoreOutVo storeOutVo) throws GenericException {
		return storeDao.listStoreOutForSupplier(pageController, storeOutVo);
	}

	@Override
	public PaginationSupport listStoreOut(PageController pageController, StoreOutVo storeOutVo) throws GenericException {
		return storeDao.listStoreOut(pageController, storeOutVo);
	}

	@Override
	public PaginationSupport listStoreInDetialed(PageController pageController, StoreInDetailedVo storeInDetailedVo) throws GenericException {
		return storeDao.listStoreInDetailed(pageController, storeInDetailedVo);
	}

	@Override
	public PaginationSupport listStoreOutDetialed(PageController pageController, StoreOutDetailedVo storeOutDetailedVo) throws GenericException {
		return storeDao.listStoreOutDetailed(pageController, storeOutDetailedVo);
	}

	@Override
	public PaginationSupport listStoreMater(PageController pageController, StoreMaterVo storeMaterVo) throws GenericException {
		return storeDao.listStoreMater(pageController, storeMaterVo);
	}

	public PaginationSupport findSupplierStoreMater(PageController pageController, StoreMaterVo storeMaterVo) throws GenericException {
		return storeDao.findSupplierStoreMater(pageController, storeMaterVo);
	}

	public PaginationSupport findSupplierStoreMaterForMinStore(PageController pageController, StoreMaterVo storeMaterVo) throws GenericException {
		return storeDao.findSupplierStoreMaterForMinStore(pageController, storeMaterVo);

	}

	public PaginationSupport findMaterByOrderDateAndSupplierMaterType(PageController pageController, StoreMaterVo storeMaterVo)
			throws GenericException {
		return storeDao.findMaterByOrderDateAndSupplierMaterType(pageController, storeMaterVo);
	}

	public PaginationSupport findMaterByOrderDateAndSupplierMaterType3(PageController pageController, StoreMaterVo storeMaterVo)
			throws GenericException {
		return storeDao.findMaterByOrderDateAndSupplierMaterType3(pageController, storeMaterVo);
	}

	@Override
	public PaginationSupport listSelectStoreMater(PageController pageController, StoreMaterVo storeMaterVo) throws GenericException {
		return storeDao.listSelectStoreMater(pageController, storeMaterVo);
	}

	@Override
	public boolean addStore(StoreVo storeVo) throws GenericException {
		// 校验 是否存在同名仓库
		List<StorePo> list = storeDao.getStorePoByStoreName(storeVo.getStoreName());
		if (list != null && list.size() > 0) {
			msg = "msg001";
			return false;
		}
		// 校验 用户是否存在仓库
		List<StorePo> list2 = storeDao.getStorePoByUserId(storeVo.getStoreCustId());
		if (list2 != null && list2.size() > 0) {
			msg = "msg002";
			return false;
		}

		// 插入
		StorePo storePo = new StorePo();
		BeanCopier copier = BeanCopier.create(StoreVo.class, StorePo.class, false);
		copier.copy(storeVo, storePo, null);
		storeDao.addStorePo(storePo);
		return true;
	}

	public void deleteStore(StoreVo storeVo) throws GenericException {
		storeDao.deleteStorePo(storeVo);
	}

	public void deleteStoreIn(StoreInVo tStoreInVo) throws GenericException {
		storeDao.deleteStorePoIn(tStoreInVo);
	}

	public void deleteStoreOut(StoreOutVo tStoreOutVo) throws GenericException {
		storeDao.deleteStorePoOut(tStoreOutVo);
	}

	public void deleteStoreIndetail(StoreInVo tStoreInVo) throws GenericException {
		storeDao.deleteStoreIndetail(tStoreInVo);
	}

	public void deleteStoreOutdetail(StoreOutVo tStoreOutVo) throws GenericException {
		storeDao.deleteStoreOutdetail(tStoreOutVo);
	}

	@Override
	public int addStoreIn(StoreInVo storeInVo, int userId) throws GenericException {

		// 根据用户id 查询库房id
		StorePo storePo = new StorePo();
		storePo = storeDao.getStorePo(String.valueOf(userId));

		StoreInPo storeInPo = new StoreInPo();
		BeanCopier copier = BeanCopier.create(StoreInVo.class, StoreInPo.class, false);
		copier.copy(storeInVo, storeInPo, null);
		storeInPo.setCustId(userId);
		storeInPo.setStoreHouseId(storePo.getStoreHouseId());
		storeDao.addStoreInPo(storeInPo);
		return storeInPo.getStoreInId();
	}

	public StoreInPo addStoreInForSup(StoreInVo storeInVo) throws GenericException {
		// 根据用户id 查询库房id
		StorePo storePo = new StorePo();
		// storePo = storeDao.getStorePo(String.valueOf(userId));

		StoreInPo storeInPo = new StoreInPo();
		BeanCopier copier = BeanCopier.create(StoreInVo.class, StoreInPo.class, false);
		copier.copy(storeInVo, storeInPo, null);
		// storeInPo.setCustId(userId);
		storeInPo.setStoreHouseId(storePo.getStoreHouseId());
		storeDao.addStoreInPo(storeInPo);
		return storeInPo;
	}

	public StoreOutPo minStoreOutForSup(StoreOutVo storeOutVo) throws GenericException {
		// 根据用户id 查询库房id
		StorePo storePo = new StorePo();
		// storePo = storeDao.getStorePo(String.valueOf(userId));

		StoreOutPo storeOutPo = new StoreOutPo();
		BeanCopier copier = BeanCopier.create(StoreOutVo.class, StoreOutPo.class, false);
		copier.copy(storeOutVo, storeOutPo, null);
		// storeInPo.setCustId(userId);
		storeOutPo.setStoreHouseId(storePo.getStoreHouseId());
		storeDao.addStoreOutPo(storeOutPo);
		return storeOutPo;
	}

	/**
	 * 生成出库价格分表
	 * */
	@Override
	public List<StoreOutDetailedValuePo> addStoreOutDetalValue(String storeOutId, List<StoreOutDetailedPo> storeOutDetailedPolist,
			List<StoreMaterDetailPo> storeMaterDetailPolist) throws GenericException {
		List<StoreOutDetailedValuePo> storeOutDetailedValuePoList = new ArrayList<StoreOutDetailedValuePo>();
		// 遍历出库表中的材料
		for (StoreOutDetailedPo storeOutDetailedPo : storeOutDetailedPolist) {
			// 准备插入 库存价格分表中的材料数量
			BigDecimal materNumber = storeOutDetailedPo.getMaterNum();
			// 遍历价格库存中的材料
			for (StoreMaterDetailPo storeMaterDetailPo : storeMaterDetailPolist) {

				if (storeMaterDetailPo.getMaterId() == storeOutDetailedPo.getMaterId()) {

					// 准备 插入 库存价格分表
					StoreOutDetailedValuePo storeOutDetailedValuePo = new StoreOutDetailedValuePo();
					storeOutDetailedValuePo.setMaterId(storeOutDetailedPo.getMaterId());
					storeOutDetailedValuePo.setMaterValueUnit(storeMaterDetailPo.getMaterValueUnit());
					storeOutDetailedValuePo.setStoreOutId(Integer.valueOf(storeOutId));
					storeOutDetailedValuePo.setSid(storeMaterDetailPo.getSid());
					// 计算实际插入的数量
					if (storeMaterDetailPo.getMaterNum().compareTo(materNumber) >= 0) {
						storeOutDetailedValuePo.setMaterNum(materNumber);
						storeDao.addStoreOutDetailedValuePo(storeOutDetailedValuePo);
						storeOutDetailedValuePoList.add(storeOutDetailedValuePo);
						break;
					} else if (storeMaterDetailPo.getMaterNum().compareTo(materNumber) < 0) {
						storeOutDetailedValuePo.setMaterNum(storeMaterDetailPo.getMaterNum());
						materNumber = materNumber.subtract(storeMaterDetailPo.getMaterNum());
						storeDao.addStoreOutDetailedValuePo(storeOutDetailedValuePo);
						storeOutDetailedValuePoList.add(storeOutDetailedValuePo);
					}

				}
			}
		}
		return storeOutDetailedValuePoList;
	}

	@Override
	public int minStoreOut(StoreOutVo storeOutVo, UserPo po) throws GenericException {

		// 根据用户id 查询库房id
		StorePo storePo = new StorePo();
		storePo = storeDao.getStorePo(String.valueOf(po.getUserId()));

		StoreOutPo storeOutPo = new StoreOutPo();
		BeanCopier copier = BeanCopier.create(StoreOutVo.class, StoreOutPo.class, false);
		copier.copy(storeOutVo, storeOutPo, null);
		storeOutPo.setCustId((int) po.getUserId());
		storeOutPo.setStoreHouseId(storePo.getStoreHouseId());
		storeDao.addStoreOutPo(storeOutPo);
		return storeOutPo.getStoreOutId();
	}

	@Override
	public void addStoreInDetailed(List<StoreMaterVo> list, int storeInId) throws GenericException {
		for (StoreMaterVo storeMaterVo : list) {
			StoreInDetailedPo storeInDetailedPo = new StoreInDetailedPo();

			BeanCopier copier = BeanCopier.create(StoreMaterVo.class, StoreInDetailedPo.class, false);
			copier.copy(storeMaterVo, storeInDetailedPo, null);
			storeInDetailedPo.setStoreInId(storeInId);
			// 手动入库 实际 和需求重量直接设置
			storeInDetailedPo.setMaterNumNeed(storeMaterVo.getMaterNum());
			storeInDetailedPo.setAccountState(0);
			storeDao.addStoreInDetailedPo(storeInDetailedPo);
		}

	}

	public void addStoreInDetailedForSup(StoreInVo storeInVo, StoreInPo storeInPo) throws GenericException {
		JSONArray array = JSONArray.fromObject(storeInVo.getMaterdategridList());
		BigDecimal materValueAll = new BigDecimal(0);
		for (int i = 0; i < array.size(); i++) {
			JSONObject object = JSONObject.fromObject(array.get(i));
			StoreInDetailedPo storeInDetailedPo = new StoreInDetailedPo();
			storeInDetailedPo.setMaterId(Integer.valueOf(object.get("materId").toString()));
			storeInDetailedPo.setMaterLevel(1);
			storeInDetailedPo.setMaterNum(new BigDecimal(object.get("materNum").toString()));
			storeInDetailedPo.setMaterNumNeed(new BigDecimal(object.get("materNum").toString()));
			storeInDetailedPo.setMaterValueUnit(new BigDecimal(object.get("materValueUndressed").toString()));
			storeInDetailedPo.setMaterValue(storeInDetailedPo.getMaterNum().multiply(storeInDetailedPo.getMaterValueUnit()));
			storeInDetailedPo.setStoreInId(storeInVo.getStoreInId());
			materValueAll = materValueAll.add(storeInDetailedPo.getMaterValue());
			storeDao.addStoreInDetailedPo(storeInDetailedPo);

			// 检索 次供货商是否有这种材料 没有就加入该供货商材料
			List<MaterLevelPo> listmaterLevel = materDaoImpl.getMaterLevelPoByMaterIdAndLevelAndSupId(storeInDetailedPo.getMaterId(),
					storeInDetailedPo.getMaterLevel(), storeInVo.getSupSupId(), "0");
			if (listmaterLevel == null || listmaterLevel.size() == 0) {
				MaterLevelPo materLevelPo = new MaterLevelPo();
				materLevelPo.setMid(0);
				materLevelPo.setSupId(storeInVo.getSupSupId());
				materLevelPo.setCustId(0);
				materLevelPo.setDeleteFlag(0);
				materLevelPo.setMaterDescribe("");
				materLevelPo.setMaterId(storeInDetailedPo.getMaterId());
				materLevelPo.setMaterLevel(storeInDetailedPo.getMaterLevel());
				materLevelPo.setMaterProportion(1);
				materLevelPo.setMaterValue(new BigDecimal(0.1));
				materLevelPo.setMaterValueUndressed(new BigDecimal(0.1));
				materDaoImpl.addMaterLevel(materLevelPo);
			}
		}
		storeInPo.setMaterValueAll(materValueAll);
		storeDao.updateStoreInPo(storeInPo);
	}

	public void addStoreInDetailedForDistributor(StoreInVo storeInVo, StoreInPo storeInPo) throws GenericException {
		OrderDistributorMaterRealPo orderDistributorMaterRealPo = new OrderDistributorMaterRealPo();
		orderDistributorMaterRealPo.setOrdId(storeInVo.getOrdId());
		List<OrderDistributorMaterRealPo> listOrderDistributorMaterRealPo = distributorDao
				.getOrderDistributorMaterRealPo(orderDistributorMaterRealPo);

		BigDecimal materValueAll = new BigDecimal(0);
		for (OrderDistributorMaterRealPo orderDistributorMaterRealPo2 : listOrderDistributorMaterRealPo) {

			StoreInDetailedPo storeInDetailedPo = new StoreInDetailedPo();
			storeInDetailedPo.setMaterId(orderDistributorMaterRealPo2.getOrdMaterId());
			storeInDetailedPo.setMaterLevel(orderDistributorMaterRealPo2.getOrdMaterLevel());
			storeInDetailedPo.setMaterNum(orderDistributorMaterRealPo2.getOrdMaterWeightReality());
			storeInDetailedPo.setMaterNumNeed(orderDistributorMaterRealPo2.getOrdMaterWeight());
			storeInDetailedPo.setMaterValueUnit(orderDistributorMaterRealPo2.getOrdMaterValueUnit());
			storeInDetailedPo.setMaterValue(orderDistributorMaterRealPo2.getOrdMaterValue());
			storeInDetailedPo.setStoreInId(storeInVo.getStoreInId());
			materValueAll = materValueAll.add(storeInDetailedPo.getMaterValue());
			storeDao.addStoreInDetailedPo(storeInDetailedPo);

			// 检索 次供货商是否有这种材料 没有就加入该供货商材料
			List<MaterLevelPo> listmaterLevel = materDaoImpl.getMaterLevelPoByMaterIdAndLevelAndSupId(storeInDetailedPo.getMaterId(),
					storeInDetailedPo.getMaterLevel(), storeInVo.getSupSupId(), "0");
			if (listmaterLevel == null || listmaterLevel.size() == 0) {
				MaterLevelPo materLevelPo = new MaterLevelPo();
				materLevelPo.setMid(0);
				materLevelPo.setSupId(storeInVo.getSupSupId());
				materLevelPo.setCustId(0);
				materLevelPo.setDeleteFlag(0);
				materLevelPo.setMaterDescribe("");
				materLevelPo.setMaterId(storeInDetailedPo.getMaterId());
				materLevelPo.setMaterLevel(storeInDetailedPo.getMaterLevel());
				materLevelPo.setMaterProportion(1);
				materLevelPo.setMaterValue(new BigDecimal(0.1));
				materLevelPo.setMaterValueUndressed(new BigDecimal(0.1));
				materDaoImpl.addMaterLevel(materLevelPo);
			}
		}
		storeInPo.setMaterValueAll(materValueAll);
		storeDao.updateStoreInPo(storeInPo);
	}

	public void minStoreOutDetailedForSup(String materdategridList, StoreOutPo storeOutPo) throws GenericException {
		JSONArray array = JSONArray.fromObject(materdategridList);
		BigDecimal storeOutValue = new BigDecimal(0);
		for (int i = 0; i < array.size(); i++) {
			JSONObject object = JSONObject.fromObject(array.get(i));
			StoreOutDetailedPo storeOutDetailedPo = new StoreOutDetailedPo();
			storeOutDetailedPo.setMaterId(Integer.valueOf(object.get("materId").toString()));
			storeOutDetailedPo.setMaterLevel(1);

			if (object.get("materNum") != null) {
				storeOutDetailedPo.setMaterNum(new BigDecimal(object.get("materNum").toString()));
			} else if (object.get("materWeight") != null) {
				storeOutDetailedPo.setMaterNum(new BigDecimal(object.get("materWeight").toString()));
			}
			storeOutDetailedPo.setMaterValueUnit(new BigDecimal(object.get("materValue").toString()));
			storeOutDetailedPo.setMaterValue(storeOutDetailedPo.getMaterNum().multiply(storeOutDetailedPo.getMaterValueUnit()));
			storeOutDetailedPo.setStoreOutId(storeOutPo.getStoreOutId());
			storeOutValue = storeOutValue.add(storeOutDetailedPo.getMaterValue());
			storeDao.addStoreOutDetailedPo(storeOutDetailedPo);
		}
		storeOutPo.setStoreOutValue(storeOutValue);
		storeDao.updateStoreOutPo(storeOutPo);
	}

	public void addStoreInDetailedOne(StoreInDetailedPo tStoreInDetailedPo) throws GenericException {
		storeDao.addStoreInDetailedPo(tStoreInDetailedPo);
	}

	@Override
	public void minStoreOutDetailed(List<StoreMaterVo> list, int storeOutId) throws GenericException {
		for (StoreMaterVo storeMaterVo : list) {
			StoreOutDetailedPo storeOutDetailedPo = new StoreOutDetailedPo();

			BeanCopier copier = BeanCopier.create(StoreMaterVo.class, StoreOutDetailedPo.class, false);
			copier.copy(storeMaterVo, storeOutDetailedPo, null);
			storeOutDetailedPo.setStoreOutId(storeOutId);
			storeDao.minStoreOutDetailedPo(storeOutDetailedPo);
		}
	}

	@Override
	public void updateStoreMater(List<StoreInDetailedPo> list, UserPo userPo) throws GenericException {

		StorePo storePo = new StorePo();
		storePo = storeDao.getStorePo(String.valueOf(userPo.getUserId()));

		List<StoreMaterPo> storeMaterPoList = null;
		storeMaterPoList = storeDao.getStoreMaterList(String.valueOf(userPo.getUserId()));

		for (StoreInDetailedPo storeInDetailedPo : list) {
			// 判断库存中是否有这些材料 默认没有
			boolean flag = false;

			for (StoreMaterPo storeMaterPo : storeMaterPoList) {
				if (storeInDetailedPo.getMaterId() == storeMaterPo.getMaterId() && storeInDetailedPo.getMaterLevel() == storeMaterPo.getMaterLevel()) {
					flag = true;
					// 计算新的材料数目
					BigDecimal num = storeInDetailedPo.getMaterNum().add(storeMaterPo.getMaterNum());
					// 入库
					storeMaterPo.setMaterNum(num);
					storeDao.addStoreMaterPo(storeMaterPo);
				}
			}

			if (!flag) {
				StoreMaterPo tStoreMaterPo = new StoreMaterPo();
				BeanCopier copier = BeanCopier.create(StoreInDetailedPo.class, StoreMaterPo.class, false);
				copier.copy(storeInDetailedPo, tStoreMaterPo, null);
				tStoreMaterPo.setStoreHouseId(storePo.getStoreHouseId());
				storeDao.addStoreMaterPo(tStoreMaterPo);
			}
		}

	}

	public void updateStoreInMaterDetailForReview(List<StoreInDetailedPo> list, int hostId, String materDay) throws GenericException {

		for (StoreInDetailedPo storeInDetailedPo : list) {
			// 取得库存材料分表数量
			/*
			 * List<StoreMaterDetailPo> tStoreMaterDetailPoList =
			 * storeDao.getStoreMaterDetailPoByHostIdAndMaterIdAndMaterDay
			 * (hostId, storeInDetailedPo.getMaterId(), materDay);
			 */
			// 取得库存材料总表数量
			List<StoreMaterPo> tStoreMaterPoList = storeDao.getStoreMaterListbyHoustIdMaterId(hostId, storeInDetailedPo.getMaterId());

			// 先计算总表
			StoreMaterPo tStoreMaterPo = new StoreMaterPo();

			if (tStoreMaterPoList != null && tStoreMaterPoList.size() > 0) {
				tStoreMaterPo = tStoreMaterPoList.get(0);
				// 正and0库存 直接增加分货量
				if (new BigDecimal(0).compareTo(tStoreMaterPo.getMaterNum()) <= 0) {
					addStoreMaterDetailPoForListIsNullOrNumIs0OrNumIsPositive(storeInDetailedPo, materDay, tStoreMaterPo.getSid(), hostId);
				} else {
					addStoreMaterDetailPoForListIsMinus(storeInDetailedPo, materDay, tStoreMaterPo.getSid(), hostId, tStoreMaterPo.getMaterNum());
				}
				// 先改变分表再改总表数量
				tStoreMaterPo.setMaterNum(tStoreMaterPo.getMaterNum().add(storeInDetailedPo.getMaterNum()));
				storeDao.updateStoreMaterPo(tStoreMaterPo);
			} else {
				tStoreMaterPo.setMaterId(storeInDetailedPo.getMaterId());
				tStoreMaterPo.setMaterLevel(1);
				tStoreMaterPo.setMaterNum(storeInDetailedPo.getMaterNum());
				tStoreMaterPo.setStoreHouseId(hostId);
				storeDao.addStoreMaterPo(tStoreMaterPo);
				// 直接增加分表不需要计算
				addStoreMaterDetailPoForListIsNullOrNumIs0OrNumIsPositive(storeInDetailedPo, materDay, tStoreMaterPo.getSid(), hostId);
			}

		}

	}

	public void addStoreMaterDetailPoForListIsNullOrNumIs0OrNumIsPositive(StoreInDetailedPo storeInDetailedPo, String materDay, int sid, int hostId)
			throws GenericException {
		StoreMaterDetailPo tStoreMaterDetailPo = new StoreMaterDetailPo();
		tStoreMaterDetailPo.setMaterDay(materDay);
		tStoreMaterDetailPo.setMaterId(storeInDetailedPo.getMaterId());
		tStoreMaterDetailPo.setMaterNum(storeInDetailedPo.getMaterNum());
		tStoreMaterDetailPo.setMaterValueUnit(storeInDetailedPo.getMaterValueUnit());
		tStoreMaterDetailPo.setMaterValue(storeInDetailedPo.getMaterValueUnit().multiply(storeInDetailedPo.getMaterNum()));
		tStoreMaterDetailPo.setSid(sid);
		tStoreMaterDetailPo.setStoreHouseId(hostId);
		storeDao.addStoreMaterDetailPo(tStoreMaterDetailPo);
	}

	public void addStoreMaterDetailPoForListIsMinus(StoreInDetailedPo storeInDetailedPo, String materDay, int sid, int hostId, BigDecimal num)
			throws GenericException {
		StoreMaterDetailPo tStoreMaterDetailPo = new StoreMaterDetailPo();
		tStoreMaterDetailPo.setMaterDay(materDay);
		tStoreMaterDetailPo.setMaterId(storeInDetailedPo.getMaterId());
		tStoreMaterDetailPo.setMaterNum(storeInDetailedPo.getMaterNum().add(num));
		tStoreMaterDetailPo.setMaterValueUnit(storeInDetailedPo.getMaterValueUnit());
		tStoreMaterDetailPo.setMaterValue(storeInDetailedPo.getMaterValueUnit().multiply(storeInDetailedPo.getMaterNum()));
		tStoreMaterDetailPo.setSid(sid);
		tStoreMaterDetailPo.setStoreHouseId(hostId);

		// 判断是否 加完 还是正数 如果正数才插入 分表 负数不改变
		if (new BigDecimal(0).compareTo(tStoreMaterDetailPo.getMaterNum()) < 0) {
			storeDao.addStoreMaterDetailPo(tStoreMaterDetailPo);
		}
	}

	public void updateStoreOutMaterDetailForReview(List<StoreOutDetailedPo> list, int hostId, String materDay) throws GenericException {
		for (StoreOutDetailedPo storeOutDetailedPo : list) {
			// 取得库存材料分表数量
			List<StoreMaterDetailPo> tStoreMaterDetailPoList = storeDao.getStoreMaterDetailPoByHostIdAndMaterIdAndMaterDay(hostId,
					storeOutDetailedPo.getMaterId());
			// 取得库存材料总表数量
			List<StoreMaterPo> tStoreMaterPoList = storeDao.getStoreMaterListbyHoustIdMaterId(hostId, storeOutDetailedPo.getMaterId());

			// 先计算总表
			StoreMaterPo tStoreMaterPo = new StoreMaterPo();// 总表数量

			if (tStoreMaterPoList != null && tStoreMaterPoList.size() > 0) {
				tStoreMaterPo = tStoreMaterPoList.get(0);
				tStoreMaterPo.setMaterNum(tStoreMaterPo.getMaterNum().subtract(storeOutDetailedPo.getMaterNum()));
				storeDao.updateStoreMaterPo(tStoreMaterPo);
			} else {
				tStoreMaterPo.setMaterId(storeOutDetailedPo.getMaterId());
				tStoreMaterPo.setMaterLevel(1);
				tStoreMaterPo.setMaterNum((new BigDecimal(0)).subtract(storeOutDetailedPo.getMaterNum()));
				tStoreMaterPo.setStoreHouseId(hostId);
				storeDao.addStoreMaterPo(tStoreMaterPo);
			}
			// 计算分表数量 start
			// 如果总表是负数 或者 0 则 不改变分表 如果 总表是正数则修改
			if (new BigDecimal(0).compareTo(tStoreMaterPo.getMaterNum()) < 0) {
				BigDecimal num = storeOutDetailedPo.getMaterNum();
				for (StoreMaterDetailPo fStoreMaterDetailPo : tStoreMaterDetailPoList) {
					if (fStoreMaterDetailPo.getMaterNum().compareTo(num) > 0) {
						fStoreMaterDetailPo.setMaterNum(fStoreMaterDetailPo.getMaterNum().subtract(num));
						storeDao.updateStoreMaterDetailPo(fStoreMaterDetailPo);
						break;
					} else {
						storeDao.deleteStoreMaterDetailPo(fStoreMaterDetailPo.getSidDetail(), fStoreMaterDetailPo.getMaterId());
						num = num.subtract(fStoreMaterDetailPo.getMaterNum());
					}
				}
			} else {
				// 如果总表为负数 删除所有分表数据
				for (StoreMaterDetailPo fStoreMaterDetailPo : tStoreMaterDetailPoList) {
					storeDao.deleteStoreMaterDetailPo(fStoreMaterDetailPo.getSidDetail(), fStoreMaterDetailPo.getMaterId());
				}
			}
		}

	}

	@Override
	public void updateStoreMaterMin(List<StoreOutDetailedPo> storeOutDetailedPolist, List<StoreMaterPo> storeMaterPoList,
			List<StoreMaterDetailPo> storeMaterDetailPolist, List<StoreOutDetailedValuePo> storeOutDetailedValuePoList) throws GenericException {
		// 计算库存总表的数量
		for (StoreOutDetailedPo storeOutDetailedPo : storeOutDetailedPolist) {
			for (StoreMaterPo storeMaterPo : storeMaterPoList) {
				if (storeMaterPo.getMaterId() == storeOutDetailedPo.getMaterId()) {
					storeMaterPo.setMaterNum(storeMaterPo.getMaterNum().subtract(storeOutDetailedPo.getMaterNum()));
					storeDao.addStoreMaterPo(storeMaterPo);
				}
			}
		}
		// 计算库存价格分表的数量
		for (StoreOutDetailedValuePo storeOutDetailedValuePo : storeOutDetailedValuePoList) {
			// 循环 库存价格分表
			for (StoreMaterDetailPo storeMaterDetailPo : storeMaterDetailPolist) {

				if (storeMaterDetailPo.getMaterId() == storeOutDetailedValuePo.getMaterId()
						&& storeMaterDetailPo.getSid() == storeOutDetailedValuePo.getSid()) {
					storeMaterDetailPo.setMaterNum(storeMaterDetailPo.getMaterNum().subtract(storeOutDetailedValuePo.getMaterNum()));
					storeDao.addStoreMaterDetailPo(storeMaterDetailPo);
				}
			}
		}

	}

	@Override
	public List<StoreInDetailedPo> getStoreInDetailedPoList(String storeInId) throws GenericException {
		return storeDao.getStoreInDetailedPoList(storeInId);
	}

	public StoreInDetailedPo getStoreInDetailedPo(int id) throws GenericException {
		return storeDao.getStoreInDetailedPo(id);

	}

	public StoreInPo getStoreInPo(int storeInId) throws GenericException {
		return storeDao.getStoreInPo(storeInId);

	}

	@Override
	public List getStoreInDetailedPoListDealValue() throws GenericException {
		return storeDao.getStoreInDetailedPoListDealValue();
	}

	public List getRealValue(int id) throws GenericException {
		return storeDao.getRealValue(id);

	}

	@Override
	public List<StoreOutDetailedPo> getStoreOutDetailedPoList(String storeOutId) throws GenericException {
		return storeDao.getStoreOutDetailedPoList(storeOutId);
	}

	public List<StoreMaterPo> getStoreMaterPoList(long userId) throws GenericException {
		return storeDao.getStoreMaterList(String.valueOf(userId));
	}

	public List<StoreMaterDetailPo> getStoreMaterDetailPoList(long userId) throws GenericException {
		return storeDao.getStoreMaterDetailPo(String.valueOf(userId));

	}

	public List<StoreInDetailedVo> getStoreInDetailedVoList(int storeInId) throws GenericException {
		List<StoreInDetailedVo> list = new ArrayList<StoreInDetailedVo>();
		List<StoreInDetailedPo> poList = storeDao.getStoreInDetailedPoList(String.valueOf(storeInId));

		for (StoreInDetailedPo storeInDetailedPo : poList) {
			StoreInDetailedVo tStoreInDetailedVo = new StoreInDetailedVo();
			BeanCopier copier = BeanCopier.create(StoreInDetailedPo.class, StoreInDetailedVo.class, false);
			copier.copy(storeInDetailedPo, tStoreInDetailedVo, null);

			MaterPo materPo = materDaoImpl.getMaterPoByMaterId(storeInDetailedPo.getMaterId()).get(0);
			tStoreInDetailedVo.setUnit(materPo.getUnit());
			tStoreInDetailedVo.setMaterName(materPo.getMaterName());
			tStoreInDetailedVo.setSpecifications(materPo.getSpecifications());
			tStoreInDetailedVo.setBrands(materPo.getBrands());
			tStoreInDetailedVo.setMaterType(materPo.getMaterType());
			list.add(tStoreInDetailedVo);
		}

		return list;
	}

	public StoreOutPo getStoreOutPoByStoreOutId(String storeOutId) throws GenericException {
		return storeDao.getStoreOutPoByStoreOutId(storeOutId);
	}

	public List<StoreOutPo> getStoreOutPoBySupIdAndOrdId(int supId, int OrdId) throws GenericException {
		return storeDao.getStoreOutPoBySupIdAndOrdId(supId, OrdId);
	}

	// 入库审核
	@Override
	public void updateStoreInForReview(String storeInId, List<StoreInDetailedPo> list) throws GenericException {
		// 改变状态
		StoreInPo storeInPo = storeDao.getStoreInPo(storeInId);
		storeInPo.setStoreInState(2);
		storeDao.addStoreInPo(storeInPo);
		/*
		 * // 改变实际重量 for (StoreInDetailedPo storeInDetailedPo : list) {
		 * StoreInDetailedPo tStoreInDetailedPo = new StoreInDetailedPo();
		 * tStoreInDetailedPo =
		 * storeDao.getStoreInDetailedPoById(storeInDetailedPo.getId());
		 * tStoreInDetailedPo.setMaterNum(storeInDetailedPo.getMaterNum());
		 * tStoreInDetailedPo.setAccountState(0);
		 * 
		 * storeDao.addStoreInDetailedPo(tStoreInDetailedPo); }
		 */

	}

	// 出库审核
	public void updateStoreOutForReview(String storeOutId, List<StoreOutDetailedPo> list) throws GenericException {
		StoreOutPo storeOutPo = storeDao.getStoreOutPoByStoreOutId(storeOutId);
		storeOutPo.setStoreOutState(2);
		storeDao.updateStoreOutPo(storeOutPo);
	}

	// 出库审核
	@Override
	public void updateStoreOut(String storeOutId) throws GenericException {
		StoreOutPo storeOutPo = storeDao.getStoreOutPoByStoreOutId(storeOutId);
		storeOutPo.setStoreOutState(2);
		storeDao.minStoreOutPo(storeOutPo);
	}

	public int getStoreHouseIdByCustId(String ordCustId) throws GenericException {
		return storeDao.getStoreHouseIdByCustId(ordCustId);
	}

	public int getStoreHouseIdBySupId(long supId) throws GenericException {
		return storeDao.getStoreHouseIdBySupId(supId);

	}

	public boolean batchSaveMater(Map<Integer, String> map) throws Exception {
		boolean flag = true;
		for (int i = 1; i <= map.size(); i++) {
			System.out.println(map.get(i));
			String[] everyline = map.get(i).split("\\*");
			if (everyline.length != 7) {
				msg = "msg007";
				throw new Exception("====error when updaa=======");
			}

			String materName = everyline[0];
			int materType = Double.valueOf(everyline[1]).intValue();
			String supName = everyline[2];
			int materLevel = Double.valueOf(everyline[3]).intValue();
			BigDecimal materValueUndressed = new BigDecimal(everyline[4]);
			BigDecimal materProportion = new BigDecimal(everyline[5]);
			String materDescribe = everyline[6];
			int supId = 0;
			List<SupplierPo> supplierPoList = supplierDao.getSupPoByName(supName);
			if (supplierPoList != null && supplierPoList.size() > 0) {
				SupplierPo tSupplierPo = supplierPoList.get(0);
				supId = tSupplierPo.getSupplierId();
			} else {
				msg = "msg006";
				throw new Exception("====error when updaa=======");
			}

			MathContext mc = new MathContext(5, RoundingMode.HALF_UP);
			BigDecimal materValueNet = materValueUndressed.multiply(new BigDecimal(0.1)).divide(materProportion, mc)
					.setScale(5, BigDecimal.ROUND_HALF_UP);

			// 查询数据库是否存在此种材料
			List<MaterPo> materPoList = materDaoImpl.getMaterPoByMaterName(materName);
			if (materPoList != null && materPoList.size() > 0) {
				MaterPo materPo = materPoList.get(0);
				materPo.setMaterDescribe(materDescribe);
				materPo.setMaterType(materType);
				materDaoImpl.updateMater(materPo);
				String custId = "0";
				List<MaterLevelPo> tMaterLevelPoList = materDaoImpl.getMaterLevelPoByMaterIdAndLevelAndSupId(materPo.getMaterId(), materLevel, supId,
						custId);
				MaterLevelPo tMaterLevelPo = null;
				if (tMaterLevelPoList != null && tMaterLevelPoList.size() > 0) {
					tMaterLevelPo = tMaterLevelPoList.get(0);
					tMaterLevelPo.setMaterProportion(materProportion.intValue());
					tMaterLevelPo.setMaterValue(materValueNet);
					tMaterLevelPo.setMaterValueUndressed(materValueUndressed.multiply(new BigDecimal(0.001)));
					tMaterLevelPo.setMaterDescribe(materDescribe);

				} else {
					tMaterLevelPo = new MaterLevelPo();
					tMaterLevelPo.setMaterId(materPo.getMaterId());
					tMaterLevelPo.setMaterLevel(materLevel);
					tMaterLevelPo.setMaterProportion(materProportion.intValue());
					tMaterLevelPo.setMaterDescribe(materDescribe);
					tMaterLevelPo.setMaterValue(materValueNet);
					tMaterLevelPo.setMaterValueUndressed(materValueUndressed.multiply(new BigDecimal(0.001)));
					tMaterLevelPo.setSupId(supId);
				}
				materDaoImpl.updateMaterLevel(tMaterLevelPo);

			} else {
				MaterPo materPo = new MaterPo();
				materPo.setMaterName(materName);
				materPo.setMaterDescribe(materDescribe);
				materPo.setMaterType(materType);
				int id = materDaoImpl.addMater(materPo);

				MaterLevelPo tMaterLevelPo = new MaterLevelPo();
				tMaterLevelPo.setMaterId(id);
				tMaterLevelPo.setMaterLevel(materLevel);
				tMaterLevelPo.setMaterProportion(materProportion.intValue());
				tMaterLevelPo.setMaterDescribe(materDescribe);
				tMaterLevelPo.setMaterValue(materValueNet);
				tMaterLevelPo.setMaterValueUndressed(materValueUndressed.multiply(new BigDecimal(0.001)));
				tMaterLevelPo.setSupId(supId);
				materDaoImpl.updateMaterLevel(tMaterLevelPo);

			}
		}
		return flag;
	}

	// 收货入库
	public boolean addStoreMaterIn(String ordId, String ordCustId, String ordSupId, String ordDate) throws GenericException {

		List<OrderSupplierMaterRealPo> orderSupplierMaterRealPoList = new ArrayList<OrderSupplierMaterRealPo>();
		orderSupplierMaterRealPoList = supplierOrderDao.getOrderSupMaterRealForInStore(ordId, ordCustId, ordSupId);

		// 首先获取仓库信息
		List<StorePo> storePoList = storeDao.getStorePoByUserId(Integer.valueOf(ordCustId));
		StorePo storePo = new StorePo();
		if (storePoList == null || storePoList.size() == 0) {
			msg = "msg0001";
			return false;
		}
		storePo = storePoList.get(0);
		// 获取仓库中的所有材料总表
		List<StoreMaterPo> storeMaterPoList = storeDao.getStoreMaterList(ordCustId);
		// StoreMaterPo storeMaterPo = new StoreMaterPo();

		// List<StoreMaterDetailPo> storeMaterDetailPoList = new
		// ArrayList<StoreMaterDetailPo>();
		// storeMaterDetailPoList = storeDao.getStoreMaterDetailPo(ordCustId);
		for (OrderSupplierMaterRealPo orderSupplierMaterRealPo : orderSupplierMaterRealPoList) {
			StoreMaterDetailPo tStoreMaterDetailPo = new StoreMaterDetailPo();
			tStoreMaterDetailPo.setMaterDay(ordDate);
			tStoreMaterDetailPo.setMaterId(orderSupplierMaterRealPo.getOrdMaterId());
			tStoreMaterDetailPo.setMaterValueUnit(orderSupplierMaterRealPo.getOrdMaterValue().divide(orderSupplierMaterRealPo.getOrdMaterWeight()));
			tStoreMaterDetailPo.setMaterNum(orderSupplierMaterRealPo.getOrdMaterWeight());
			tStoreMaterDetailPo.setStoreHouseId(storePo.getStoreHouseId());
			// 关联仓库材料总表id
			StoreMaterPo storeMaterPoForNumber = new StoreMaterPo();

			boolean flagHaveMater = false;// 默认总表没有
			for (StoreMaterPo storeMaterPo : storeMaterPoList) {
				if (storeMaterPo.getMaterId() == orderSupplierMaterRealPo.getOrdMaterId()) {
					tStoreMaterDetailPo.setSid(storeMaterPo.getSid());
					storeDao.addStoreMaterDetailPo(tStoreMaterDetailPo);
					storeMaterPoForNumber = storeMaterPo;
					flagHaveMater = true;
				}
			}
			if (!flagHaveMater) {// 如果仓库没此种材料
				storeMaterPoForNumber.setMaterId(orderSupplierMaterRealPo.getOrdMaterId());
				storeMaterPoForNumber.setStoreHouseId(storePo.getStoreHouseId());
				storeMaterPoForNumber.setMaterLevel(1);
				storeMaterPoForNumber.setMaterNum(new BigDecimal(0));
				storeDao.addStoreMaterPoPersist(storeMaterPoForNumber);
				tStoreMaterDetailPo.setSid(storeMaterPoForNumber.getSid());
				storeDao.addStoreMaterDetailPo(tStoreMaterDetailPo);
			}
			flagHaveMater = false;// 还原flag
			if (!integrationStoreMaterPo(storePo.getStoreHouseId(), orderSupplierMaterRealPo.getOrdMaterId(), storeMaterPoForNumber,
					tStoreMaterDetailPo)) {
				return false;
			}
		}

		return true;
	}

	// 整合仓库总表
	boolean integrationStoreMaterPo(int storeHouseId, int materId, StoreMaterPo storeMaterPo, StoreMaterDetailPo storeMaterDetailPo)
			throws GenericException {
		// 算出分表总和插入总表
		storeMaterPo.setMaterNum(storeMaterPo.getMaterNum().add(storeMaterDetailPo.getMaterNum()));
		storeDao.addStoreMaterPo(storeMaterPo);
		return true;
	}

	@Override
	public void updateStoreOutPoForReviewStoreOut(List<StoreOutDetailedValuePo> storeOutDetailedValuePoList, StoreOutPo storeOutPo)
			throws GenericException {
		// List list = storeDao.computerStoreValue();
		BigDecimal storeOutValue = new BigDecimal(0);

		for (StoreOutDetailedValuePo storeOutDetailedValuePo : storeOutDetailedValuePoList) {
			storeOutValue = storeOutValue.add(storeOutDetailedValuePo.getMaterNum().multiply(storeOutDetailedValuePo.getMaterValueUnit()));
		}
		storeOutPo.setStoreOutValue(storeOutValue);
		storeOutPo.setStoreOutState(2);
		storeDao.updateStoreOutPo(storeOutPo);
	}

	public boolean checkStoreOutHaveConfirm(long userId) throws GenericException {
		List<StoreOutPo> storeOutPoList = storeDao.getStoreOutPoForCheckConfirm(storeDao.getStoreHouseIdByCustId(String.valueOf(userId)));
		if (storeOutPoList != null && storeOutPoList.size() > 0) {
			return false;
		}
		return true;
	}

	public String pulldownStoreOutWay(int space) throws GenericException {
		List<Code> codeList = dataDictionaryDao.findCodeIdList("store_out_way");
		StringBuffer ql = new StringBuffer();
		ql.append("[");
		if (space == 1) {
			ql.append("{\"storeOutWay\":\"0\",\"storeOutWayName\":\"无\"},");
		}
		String q2 = "";
		if (codeList != null && codeList.size() > 0) {
			for (Code code : codeList) {
				ql.append("{\"storeOutWay\":\"" + code.getCodeId() + "\",\"storeOutWayName\":\"" + code.getCodeName() + "\"},");
			}
			q2 = ql.substring(0, ql.length() - 1) + "]";
		}
		return q2;
	}

}
